BicyclesController - Code Metrics - Inspection of "Merge pull request #74 from KarlComSe/chore/update..." - KarlComSe/SvenskaElsparkcyklarAB - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — development ( 26403f...98b3d9 )

by Vad

created 2025-01-05 16:07 UTC

BicyclesController A

↳ Parent: backend/src/bicycles/bicycles.controller.ts

Complexity

Total Complexity

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes

Metric	Value
eloc	149
dl	0
loc	183
ccs	24
cts	28
cp	0.8571
rs	10
c	0
b	0
f	0
wmc	15

6 Functions

Rating	Name	Size	Complexity
A	getBikeById	25	1
A	getBicyclesByCity	21	1
A	updateBicycle	33	1
A	createManyBikes	26	3
B	getAllBicycles	51	8
A	createABike	17	1

import {
  Controller,
  Get,
  Post,
  Param,
  Patch,
  Body,
  Query,
  BadRequestException,
} from '@nestjs/common';
import {
  ApiBearerAuth,
  ApiOperation,
  ApiResponse,
  ApiParam,
  ApiBody,
  ApiTags,
  ApiQuery,
} from '@nestjs/swagger';
// we have removed all JwtAuthGuards from this route.
//  import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { BicyclesService } from './bicycles.service';
import { UpdateBicycleDto } from './dto/update-bicycle.dto';
import { Bicycle } from './entities/bicycle.entity';
import { BicycleResponse } from './types/bicycle-response.interface';
import { CreateBicycleDto } from './dto/create-bicycle.dto';
import { CityName } from 'src/cities/types/city.enum';

const BIKE_ID = 'b1e77dd3-9fb9-4e6c-a5c6-b6fc58f59464';
const BIKE_STATUS_AVAILABLE = 'Available';

const CREATED_AT = '2024-12-01T05:01:01.000Z';

const UPDATED_AT = '2024-12-07T18:30:30.000Z';

const UNAUTHORIZED_ERROR_MESSAGE = 'Unauthorized. Authentication required';
const CITY_ID_GOTHENBURG = '123e4567-e89b-12d3-a456-426614174000';


@ApiTags('Bicycles')
@Controller({ path: 'bike', version: '1' })
export class BicyclesController {
  constructor(private readonly bicyclesService: BicyclesService) {}

  @Get()
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get all bicycles' })
  @ApiQuery({
    name: 'city',
    required: false,
    enum: CityName,
  })
  @ApiQuery({ name: 'lat', required: false, minimum: -90, maximum: 90 })
  @ApiQuery({ name: 'lon', required: false, minimum: -180, maximum: 180 })
  @ApiQuery({ name: 'radius', required: false, minimum: 0, maximum: 100000 })
  @ApiResponse({
    status: 200,
    description: 'List of bicycles',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 401,
    description: 'Unauthorized. Authentication required',
  })
  async getAllBicycles(
    @Query('lat') lat?: string,
    @Query('lon') lon?: string,
    @Query('radius') radius?: string,
    @Query('city') city?: CityName,
  ): Promise<BicycleResponse[]> {
    const latitude = lat ? parseFloat(lat) : undefined;
    const longitude = lon ? parseFloat(lon) : undefined;
    const radi = radius ? parseFloat(radius) : 3000;

    if ((latitude && !longitude) || (longitude && !latitude)) {
      throw new BadRequestException('Both lat and lon must be provided for location search');
    }

    if (city) {
      if (latitude) {
        return this.bicyclesService.toBicycleResponses(
          await this.bicyclesService.findByCityAndLocation(city, latitude, longitude, radi),
        );
      }
      return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findByCity(city));
    }

    if (latitude) {
      return this.bicyclesService.toBicycleResponses(
        await this.bicyclesService.findByLocation(latitude, longitude, radi),
      );
    }

    return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findAll());
  }

  @Post('create')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Create a new bicycle' })
  @ApiBody({
    type: CreateBicycleDto,
    description: 'Bicycle creation data',
    required: false,
  })
  @ApiResponse({
    status: 201,
    description: 'Bicycle created successfully',
    type: Bicycle,
  })
  async createABike(@Body() createBicycleDto: CreateBicycleDto): Promise<Bicycle> {
    console.log('skapa cykel');
    return await this.bicyclesService.createBike(createBicycleDto);
  }

  @Post('create-many')
  @ApiBearerAuth()
  @ApiOperation({
    summary: 'Create multiple bicycles',
    description: 'Creates multiple bicycles in a single request. At least one bicycle must be provided.',

  })
  @ApiBody({
    type: [CreateBicycleDto],
    description: 'Array of bicycle creation data',
    required: true,
  })
  @ApiResponse({
    status: 201,
    description: 'Bicycles created successfully',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 400,
    description: 'Bad Request - Empty array or invalid bicycle data provided',
  })
  async createManyBikes(@Body() createBicycleDto: CreateBicycleDto[]): Promise<Bicycle[]> {
    if (!createBicycleDto?.length) {
      throw new BadRequestException('At least one bike is required');
    }
    return await this.bicyclesService.createManyBikes(createBicycleDto);
  }

  @Get(':bikeId')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get a bicycle by ID' })
  @ApiParam({
    name: 'bikeId',
    description: 'Unique identifier of the bicycle',
    type: 'string',
    example: BIKE_ID,
  })
  @ApiResponse({
    status: 200,
    description: 'Bicycle details retrieved successfully',
    type: Bicycle,
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  @ApiResponse({
    status: 404,
    description: 'Bicycle not found',
  })
  async getBikeById(@Param('bikeId') id: string): Promise<Bicycle> {
    return await this.bicyclesService.findById(id);
  }

  @Patch(':bikeId')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Update bicycle by ID' })
  @ApiParam({
    name: 'bikeId',
    description: 'Unique identifier of the bicycle',
    type: 'string',
    example: BIKE_ID,
  })
  @ApiBody({
    description: 'Bicycle update details',
    type: UpdateBicycleDto,
  })
  @ApiResponse({
    status: 200,
    description: 'Bicycle updated successfully',
    type: Bicycle

  })
  @ApiResponse({
    status: 400,
    description: 'Invalid input',
  })
  @ApiResponse({
    status: 404,
    description: 'Bicycle not found',
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  async updateBicycle(@Param('bikeId') bikeId: string, @Body() updateBicycleDto: UpdateBicycleDto) {
    return this.bicyclesService.update(bikeId, updateBicycleDto);
  }

  @Get('city/:cityName')
  @ApiBearerAuth()
  @ApiOperation({ summary: 'Get all bicycles in a specific city' })
  @ApiResponse({
    status: 200,
    description: 'List of bicycles in the specified city',
    type: [Bicycle],
  })
  @ApiResponse({
    status: 401,
    description: UNAUTHORIZED_ERROR_MESSAGE,
  })
  @ApiParam({
    name: 'cityName',
    description: 'Name of the city',
    type: 'string',
    enum: CityName,
  })
  async getBicyclesByCity(@Param('cityName') cityName: CityName): Promise<Bicycle[]> {
    return await this.bicyclesService.findByCity(cityName);
  }
}


1	6	import {
2		Controller,
3		Get,
4		Post,
5		Param,
6		Patch,
7		Body,
8		Query,
9		BadRequestException,
10		} from '@nestjs/common';
11	6	import {
12		ApiBearerAuth,
13		ApiOperation,
14		ApiResponse,
15		ApiParam,
16		ApiBody,
17		ApiTags,
18		ApiQuery,
19		} from '@nestjs/swagger';
20		// we have removed all JwtAuthGuards from this route.
21		// import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
22	6	import { BicyclesService } from './bicycles.service';
23	6	import { UpdateBicycleDto } from './dto/update-bicycle.dto';
24	6	import { Bicycle } from './entities/bicycle.entity';
25		import { BicycleResponse } from './types/bicycle-response.interface';
26	6	import { CreateBicycleDto } from './dto/create-bicycle.dto';
27	6	import { CityName } from 'src/cities/types/city.enum';
28
29	6	const BIKE_ID = 'b1e77dd3-9fb9-4e6c-a5c6-b6fc58f59464';
30	6	const BIKE_STATUS_AVAILABLE = 'Available';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'BIKE_STATUS_AVAILABLE' is assigned a value but never used. Loading history...
31	6	const CREATED_AT = '2024-12-01T05:01:01.000Z';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'CREATED_AT' is assigned a value but never used. Loading history...
32	6	const UPDATED_AT = '2024-12-07T18:30:30.000Z';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'UPDATED_AT' is assigned a value but never used. Loading history...
33	6	const UNAUTHORIZED_ERROR_MESSAGE = 'Unauthorized. Authentication required';
34	6	const CITY_ID_GOTHENBURG = '123e4567-e89b-12d3-a456-426614174000';
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report 'CITY_ID_GOTHENBURG' is assigned a value but never used. Loading history...
35
36		@ApiTags('Bicycles')
37		@Controller({ path: 'bike', version: '1' })
38	6	export class BicyclesController {
39	8	constructor(private readonly bicyclesService: BicyclesService) {}
40
41		@Get()
42		@ApiBearerAuth()
43		@ApiOperation({ summary: 'Get all bicycles' })
44		@ApiQuery({
45		name: 'city',
46		required: false,
47		enum: CityName,
48		})
49		@ApiQuery({ name: 'lat', required: false, minimum: -90, maximum: 90 })
50		@ApiQuery({ name: 'lon', required: false, minimum: -180, maximum: 180 })
51		@ApiQuery({ name: 'radius', required: false, minimum: 0, maximum: 100000 })
52		@ApiResponse({
53		status: 200,
54		description: 'List of bicycles',
55		type: [Bicycle],
56		})
57		@ApiResponse({
58		status: 401,
59		description: 'Unauthorized. Authentication required',
60		})
61	6	async getAllBicycles(
62		@Query('lat') lat?: string,
63		@Query('lon') lon?: string,
64		@Query('radius') radius?: string,
65		@Query('city') city?: CityName,
66		): Promise<BicycleResponse[]> {
67	4	const latitude = lat ? parseFloat(lat) : undefined;
68	4	const longitude = lon ? parseFloat(lon) : undefined;
69	4	const radi = radius ? parseFloat(radius) : 3000;
70
71	5	if ((latitude && !longitude) \|\| (longitude && !latitude)) {
72	1	throw new BadRequestException('Both lat and lon must be provided for location search');
73		}
74
75	3	if (city) {
76	1	if (latitude) {
77		return this.bicyclesService.toBicycleResponses(
78		await this.bicyclesService.findByCityAndLocation(city, latitude, longitude, radi),
79		);
80		}
81	1	return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findByCity(city));
82		}
83
84	2	if (latitude) {
85	1	return this.bicyclesService.toBicycleResponses(
86		await this.bicyclesService.findByLocation(latitude, longitude, radi),
87		);
88		}
89
90	1	return this.bicyclesService.toBicycleResponses(await this.bicyclesService.findAll());
91		}
92
93		@Post('create')
94		@ApiBearerAuth()
95		@ApiOperation({ summary: 'Create a new bicycle' })
96		@ApiBody({
97		type: CreateBicycleDto,
98		description: 'Bicycle creation data',
99		required: false,
100		})
101		@ApiResponse({
102		status: 201,
103		description: 'Bicycle created successfully',
104		type: Bicycle,
105		})
106	6	async createABike(@Body() createBicycleDto: CreateBicycleDto): Promise<Bicycle> {
107	1	console.log('skapa cykel');
108	1	return await this.bicyclesService.createBike(createBicycleDto);
109		}
110
111		@Post('create-many')
112		@ApiBearerAuth()
113		@ApiOperation({
114		summary: 'Create multiple bicycles',
115		description: 'Creates multiple bicycles in a single request. At least one bicycle must be provided.',
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report Insert `⏎·····` Loading history...
116		})
117		@ApiBody({
118		type: [CreateBicycleDto],
119		description: 'Array of bicycle creation data',
120		required: true,
121		})
122		@ApiResponse({
123		status: 201,
124		description: 'Bicycles created successfully',
125		type: [Bicycle],
126		})
127		@ApiResponse({
128		status: 400,
129		description: 'Bad Request - Empty array or invalid bicycle data provided',
130		})
131	6	async createManyBikes(@Body() createBicycleDto: CreateBicycleDto[]): Promise<Bicycle[]> {
132	1	if (!createBicycleDto?.length) {
133		throw new BadRequestException('At least one bike is required');
134		}
135		return await this.bicyclesService.createManyBikes(createBicycleDto);
136		}
137
138		@Get(':bikeId')
139		@ApiBearerAuth()
140		@ApiOperation({ summary: 'Get a bicycle by ID' })
141		@ApiParam({
142		name: 'bikeId',
143		description: 'Unique identifier of the bicycle',
144		type: 'string',
145		example: BIKE_ID,
146		})
147		@ApiResponse({
148		status: 200,
149		description: 'Bicycle details retrieved successfully',
150		type: Bicycle,
151		})
152		@ApiResponse({
153		status: 401,
154		description: UNAUTHORIZED_ERROR_MESSAGE,
155		})
156		@ApiResponse({
157		status: 404,
158		description: 'Bicycle not found',
159		})
160	6	async getBikeById(@Param('bikeId') id: string): Promise<Bicycle> {
161	1	return await this.bicyclesService.findById(id);
162		}
163
164		@Patch(':bikeId')
165		@ApiBearerAuth()
166		@ApiOperation({ summary: 'Update bicycle by ID' })
167		@ApiParam({
168		name: 'bikeId',
169		description: 'Unique identifier of the bicycle',
170		type: 'string',
171		example: BIKE_ID,
172		})
173		@ApiBody({
174		description: 'Bicycle update details',
175		type: UpdateBicycleDto,
176		})
177		@ApiResponse({
178		status: 200,
179		description: 'Bicycle updated successfully',
180		type: Bicycle
		0 ignored issues – show introduced 2025-01-02 13:12 UTC by Report Bug Copy Issue Report Insert `,` Loading history...
181		})
182		@ApiResponse({
183		status: 400,
184		description: 'Invalid input',
185		})
186		@ApiResponse({
187		status: 404,
188		description: 'Bicycle not found',
189		})
190		@ApiResponse({
191		status: 401,
192		description: UNAUTHORIZED_ERROR_MESSAGE,
193		})
194	6	async updateBicycle(@Param('bikeId') bikeId: string, @Body() updateBicycleDto: UpdateBicycleDto) {
195	1	return this.bicyclesService.update(bikeId, updateBicycleDto);
196		}
197
198		@Get('city/:cityName')
199		@ApiBearerAuth()
200		@ApiOperation({ summary: 'Get all bicycles in a specific city' })
201		@ApiResponse({
202		status: 200,
203		description: 'List of bicycles in the specified city',
204		type: [Bicycle],
205		})
206		@ApiResponse({
207		status: 401,
208		description: UNAUTHORIZED_ERROR_MESSAGE,
209		})
210		@ApiParam({
211		name: 'cityName',
212		description: 'Name of the city',
213		type: 'string',
214		enum: CityName,
215		})
216	6	async getBicyclesByCity(@Param('cityName') cityName: CityName): Promise<Bicycle[]> {
217		return await this.bicyclesService.findByCity(cityName);
218		}
219		}
220

KarlComSe / SvenskaElsparkcyklarAB

Push — development ( 26403f...98b3d9 )

BicyclesController A

Complexity

Size/Duplication

Test Coverage

Importance

6 Functions

Duplication Side-by-Side

Filter issues like